﻿using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Win32;

namespace YNCNumberSys
{
    /// <summary>
    /// CAD工作环境注册模型的摘要说明。
    /// AutoCAD自动加载的注册表操作
    /// 类库开发：钟庆斌
    /// 时间：2011年10月15日
    /// 功能：注册表操作
    /// </summary>
    public class RegAcadClass
    {
        #region 基本属性

        /// <summary>
        /// 构造注册表的根键
        /// </summary>
        public RegistryKey 注册表根键
        { get; set; }

        public RegAcadClass()
            : base()
        {
            注册表根键 = Registry.LocalMachine;
        }

        public RegAcadClass(string _注册表根键)
            : base()
        {
            设置注册表当前根建(_注册表根键);
        }
        #endregion
        /// <summary>
        /// 改变注册表的根建。通常一个应用程序的相关的注册表项分布在不同的根建下，
        /// </summary>
        /// <param name="_注册表根键"></param>
        public void 设置注册表当前根建(string _注册表根键)
        {
            switch (_注册表根键.ToUpper())
            {
                case "CLASSES_ROOT":
                    注册表根键 = Registry.ClassesRoot;
                    break;
                case "CURRENT_USER":
                    注册表根键 = Registry.CurrentUser;
                    break;
                case "LOCAL_MACHINE":
                    注册表根键 = Registry.LocalMachine;
                    break;
                case "USERS":
                    注册表根键 = Registry.Users;
                    break;
                case "CURRENT_CONFIG":
                    注册表根键 = Registry.CurrentConfig;
                    break;
                case "DYN_DATA":
                    注册表根键 = Registry.DynData;
                    break;
                case "PERFORMANCE_DATA":
                    注册表根键 = Registry.PerformanceData;
                    break;
                default:
                    注册表根键 = Registry.LocalMachine;
                    break;
            }
        }
        /// <summary>
        /// 读取注册表路径下键名为“键名”的注册表键值，缺省返回“缺省值”
        /// </summary>
        /// <param name="注册表路径"></param>
        /// <param name="键名"></param>
        /// <param name="缺省值"></param>
        /// <returns></returns>
        public string 获取注册表的值(string 注册表路径, string 键名, string 缺省值)
        {
            try
            {
                RegistryKey 键 = 注册表根键.OpenSubKey(注册表路径);
                return 键.GetValue(键名, (object)缺省值).ToString();
            }
            catch
            {
                return 缺省值;
            }
        }
        /// <summary>
        /// 注册自动加载的AutoCAD程序
        /// </summary>
        /// <param name="注册表路径"></param>
        /// <param name="键名"></param>
        /// <param name="描述"></param>
        /// <param name="注册DLL文件全路径"></param>
        /// <returns></returns>
        public bool 注册自动加载的AutoCAD程序(string 注册表路径, string 键名, string 描述, string 注册DLL文件全路径)
        {
            try
            {
                RegistryKey Applications键 = 注册表根键.OpenSubKey(注册表路径, true);//打开Applications
                RegistryKey 新键 = Applications键.CreateSubKey(键名);
                新键.SetValue("DESCRIPTION", 描述, RegistryValueKind.String);
                新键.SetValue("LOADCTRLS", 2, RegistryValueKind.DWord);
                新键.SetValue("LOADER", 注册DLL文件全路径, RegistryValueKind.String);
                新键.SetValue("MANAGED", 1, RegistryValueKind.DWord);
                Applications键.Close();
                return true;
            }
            catch 
            {
                return false;
            }
        }
        /// <summary>
        /// 卸载自动加载的AutoCAD程序
        /// </summary>
        /// <param name="注册表路径"></param>
        /// <param name="键名"></param>
        /// <returns></returns>
        public bool 卸载自动加载的AutoCAD程序(string 注册表路径, string 键名)
        {
            try
            {
                RegistryKey Applications键 = 注册表根键.OpenSubKey(注册表路径, true);
                Applications键.DeleteSubKeyTree(键名);
                return true;
            }
            catch 
            {
                return false;
            }

        }
        /// <summary>
        /// 查询注册表键下的子键
        /// </summary>
        /// <param name="注册表路径"></param>
        /// <param name="根键"></param>
        /// <returns></returns>
        public List<string> 查询注册表键下的子键(string 注册表路径, RegistryKey 根键)
        {
            List<string> 返回值 = new List<string>();
            try
            {
                RegistryKey Profiles键 = 根键.OpenSubKey(注册表路径, true);
                //Profiles键.SubKeyCount;
                string[] 子键名数组 = Profiles键.GetSubKeyNames();
                foreach (string 子键名 in 子键名数组)
                {
                    返回值.Add(子键名);
                }
                Profiles键.Close();
                return 返回值;
            }
            catch 
            {
                return 返回值;
            }
        }
        /// <summary>
        /// 创注册表路径下的子键
        /// </summary>
        /// <param name="keypath"></param>
        /// <returns></returns>
        public RegistryKey 创注册表路径下的子键(string 注册表路径)
        {
            try
            {
                return 注册表根键.CreateSubKey(注册表路径);
            }
            catch
            {
                return null;
            }
        }
        /// <summary>
        /// 设置路径为注册表路径，子项名的注册表键值为子项值
        /// </summary>
        /// <param name="注册表路径"></param>
        /// <param name="子项名"></param>
        /// <param name="子项值"></param>
        public bool 设置注册表路径的子项值(string 注册表路径, string 子项名, string 子项值)
        {
            try
            {
                RegistryKey 新键 = 注册表根键.OpenSubKey(注册表路径, true);
                新键.SetValue(子项名, 子项值, RegistryValueKind.String);
                新键.Close();
                return true;
            }
            catch
            {
                return false;
            }
        }
        /// <summary>
        /// 设置路径为注册表路径，子项名的注册表键值为子项值
        /// </summary>
        /// <param name="注册表路径"></param>
        /// <param name="子项名"></param>
        /// <param name="子项值"></param>
        /// <param name="根键"></param>
        public bool 设置注册表路径的子项值(string 注册表路径, string 子项名, string 子项值, RegistryKey 根键)
        {
            try
            {
                RegistryKey 新键 = 根键.OpenSubKey(注册表路径, true);
                新键.SetValue(子项名, 子项值, RegistryValueKind.String);
                新键.Close();
                return true;
            }
            catch
            {
                return false;
            }
        }
        /// <summary>
        /// 读取注册表路径下键名为“键名”的注册表键值，缺省返回“缺省值”
        /// </summary>
        /// <param name="注册表路径"></param>
        /// <param name="键名"></param>
        /// <param name="缺省值"></param>
        /// <returns></returns>
        public string 获取注册表的值(string 注册表路径, string 键名, string 缺省值, RegistryKey 根键)
        {
            try
            {
                RegistryKey 键 = 根键.OpenSubKey(注册表路径, true);
                return 键.GetValue(键名, (object)缺省值).ToString();
            }
            catch
            {
                return 缺省值;
            }
        }
        /// <summary>
        /// 从字符串中删除指定的字符
        /// </summary>
        /// <param name="原始字符串"></param>
        /// <param name="要被删除的字符串"></param>
        /// <returns></returns>
        public string 从字符串中删除指定的字符(string 原始字符串, string 要被删除的字符)
        {
            StringBuilder 返回的结果 = new StringBuilder(原始字符串.Length);

            Dictionary<char, bool> dictionary = new Dictionary<char, bool>();

            foreach (char ch in 要被删除的字符)
            {
                dictionary[ch] = true;
            }

            foreach (char ch in 原始字符串)
            {
                if (!dictionary.ContainsKey(ch))
                {
                    返回的结果.Append(ch);
                }
            }

            return 返回的结果.ToString();
        }
        /// <summary>
        /// 从字符串中删除指定的字符串
        /// </summary>
        /// <param name="原始字符串"></param>
        /// <param name="要被删除的字符串"></param>
        /// <returns></returns>
        public string 从字符串中删除指定的字符串(string 原始字符串, string 要被删除的字符, char[] 分隔符)
        {
            StringBuilder 返回的结果 = new StringBuilder(原始字符串.Length);

            string[] 分隔结果 = 原始字符串.Split(分隔符, StringSplitOptions.None);
            foreach (string value in 分隔结果)
            {
                if (value != 要被删除的字符 && value != "")
                {
                    返回的结果.Append(value);
                    返回的结果.Append(分隔符);
                }
            }
            return 返回的结果.ToString();
        }
    }
}